class JapaneseWordSorter:
    def __init__(self):
        pass

    def extract_keyword(self, line):
        """提取第一个箭头前的日语词（汉字部分）"""
        if '→' in line:
            return line.split('→')[0].strip()
        return line.strip()

    def calculate_positional_similarity(self, word1, word2):
        """计算两个词语的相似度：前面字越相同，得分越高"""
        if not word1 or not word2:
            return 0.0

        min_len = min(len(word1), len(word2))
        max_len = max(len(word1), len(word2))
        total_score = 0.0
        max_possible = 0.0

        for i in range(max_len):
            weight = 1.0 / (1.0 + i * 0.3)
            if i < min_len:
                if word1[i] == word2[i]:
                    total_score += weight
            max_possible += weight

        return total_score / max_possible if max_possible else 0.0

    def group_by_first_char(self, keywords_with_indices):
        """按照首字符分组"""
        groups = {}
        for idx, keyword in keywords_with_indices:
            first_char = keyword[0] if keyword else ''
            groups.setdefault(first_char, []).append((idx, keyword))
        return groups

    def group_by_common_strings(self, keywords_with_indices):
        """按照包含的相同字符串分组"""
        groups = {}

        for idx, keyword in keywords_with_indices:
            if not keyword:
                continue

            # 为每个关键词生成所有可能的子串（用于匹配包含关系）
            found_group = False
            for existing_key in list(groups.keys()):
                # 如果当前关键词包含已存在的组关键词，或者已存在的组关键词包含当前关键词
                if existing_key in keyword or keyword in existing_key:
                    groups[existing_key].append((idx, keyword))
                    found_group = True
                    break

            # 如果没有找到合适的组，创建新组
            if not found_group:
                groups[keyword] = [(idx, keyword)]

        return groups
    def sort_within_group(self, group_items):
        """组内按相似度排序"""
        if len(group_items) <= 1:
            return [item[0] for item in group_items]

        ref_idx, ref_word = group_items[0]
        scored = []
        for idx, word in group_items[1:]:
            score = self.calculate_positional_similarity(ref_word, word)
            scored.append((idx, word, score))

        scored.sort(key=lambda x: x[2], reverse=True)
        return [ref_idx] + [x[0] for x in scored]

    def sort_lines(self, text):
        """主排序逻辑 - 修改为接受字符串输入"""
        if not text:
            return []

        # 分割字符串为行列表
        lines = [line.strip() for line in text.strip().split('\n') if line.strip()]

        keywords = [(i, self.extract_keyword(line)) for i, line in enumerate(lines)]
        groups = self.group_by_common_strings(keywords)
        sorted_indices = []

        for char, group in sorted(groups.items()):
            if len(group) > 1:
                sorted_indices += self.sort_within_group(group)
            else:
                sorted_indices.append(group[0][0])

        return [lines[i] for i in sorted_indices]

    def remove_duplicate_lines_preserve_all(self, text):
        """
        去除重复行，完全保留原始结构（包括重复行之间的空行）

        Args:
            text (str): 输入的多行文本字符串

        Returns:
            str: 去除重复行后的文本字符串
        """
        if not text:
            return ""

        lines = text.split('\n')
        seen = set()
        result_lines = []

        for line in lines:
            if line.strip():  # 非空行
                content_key = line.strip()
                if content_key not in seen:
                    seen.add(content_key)
                    result_lines.append(line)
                # 如果重复，跳过该非空行
            else:  # 空行，直接保留
                result_lines.append(line)

        return '\n'.join(result_lines)

    def sort_and_print(self, text):
        """排序并打印结果"""
        sorted_lines = self.sort_lines(text)
        print("排序后的结果:")
        print("-" * 30)
        for line in sorted_lines:
            print(line)
        return "\n".join(sorted_lines)

    def sort_by_first_part_length(self, text):
        """
        按照第一个箭头前的字符串长度进行排序
        """
        if not text:
            return ""

        # 分割文本为行列表
        lines = [line.strip() for line in text.split('\n') if line.strip()]

        def get_first_part_length(line):
            """提取第一个箭头前的部分并返回其长度"""
            if '→' in line:
                first_part = line.split('→')[0].strip()
                return len(first_part)
            return len(line.strip())

        # 按照第一个箭头前的字符串长度排序
        sorted_lines = sorted(lines, key=get_first_part_length)

        return "\n".join(sorted_lines)

    def sort_by_first_part_length_desc(self, text):
        """
        按照第一个箭头前的字符串长度进行降序排序

        Args:
            text (str): 输入的多行文本字符串

        Returns:
            list: 排序后的行列表
        """
        if not text:
            return ""

        lines = [line.strip() for line in text.split('\n') if line.strip()]

        def get_first_part_length(line):
            if '→' in line:
                first_part = line.split('→')[0].strip()
                return len(first_part)
            return len(line.strip())

        # 降序排序
        sorted_lines = sorted(lines, key=get_first_part_length, reverse=True)

        return "\n".join(sorted_lines)
# 使用示例
if __name__ == "__main__":
    sorter = JapaneseWordSorter()

    input_data = '''名誉 → めいよ → 名誉 / 荣誉
巧緻 → こうち → 巧妙 / 精致
累計 → るいけい → 累计 / 总计
巧緻 → こうち → 巧妙 / 精致
居候 → いそうろう → 居候 / 暂住寄宿
駆使 → くし → 熟练运用 / 驱使
巧qwq → こうち → 巧妙 / 精致
阿笠 → あがさ → 阿笠（人名）
顕巧 → けんちょ → 显著 / 明显'''
    # 输入数据

    print("原始数据:")
    print(input_data)
    print()

    # 排序并显示结果
    sorter.sort_and_print(input_data)